//工具函数库

import websiteConfigs from './globalConfigs'; // 站点配置
import {
	fetch
} from './request/index.js' // 网路请求 // 导入http请求
/**
 * @desc 日期/时间格式化
 * @param  {String} _time 需要格式化的时间字符串 如: '2018-11-16' 或者时间戳
 * @param {String} formatStr需要格式化的字符串,如 'yyyy-MM-dd' ,'yyyy年-MM月-dd日'等
 * @return {String} 返回格式化后的时间字符串
 * e.g: new Date().format("yyyy-MM-dd hh:mm:ss")
 */
function formatDate(_time, formatStr) {
	if (typeof(Date.prototype.formatDate) != 'function') {
		Date.prototype.formatDate = function(format) {
			var $1, o = {
				"M+": this.getMonth() + 1, // 月份，从0开始算
				"d+": this.getDate(), // 日期
				"h+": this.getHours(), // 小时
				"m+": this.getMinutes(), // 分钟
				"s+": this.getSeconds(), // 秒钟
				// 季度 quarter
				"q+": Math.floor((this.getMonth() + 3) / 3),
				"S": this.getMilliseconds() // 千秒
			};
			var key, value;

			if (/(y+)/.test(format)) {
				$1 = RegExp.$1,
					format = format.replace($1, String(this.getFullYear()).substr(4 - $1));
			}

			for (key in o) { // 如果没有指定该参数，则子字符串将延续到 stringvar 的最后。
				if (new RegExp("(" + key + ")").test(format)) {
					$1 = RegExp.$1,
						value = String(o[key]),
						value = $1.length == 1 ? value : ("00" + value).substr(value.length),
						format = format.replace($1, value);
				}
			}
			return format;
		};
	}
	if (formatStr && _time)
		return new Date(_time).formatDate(formatStr);

	return '';

}
/*  根据坐标获取地理位置，百度地图 location: 经度,纬度  */
async function getLocalPosition(location){
	
	let locationRes = await uni.request({
		url: 'https://restapi.amap.com/v3/geocode/regeo',
		data:{
			output: 'json',
			key: websiteConfigs.mapKey,
			location: location,
		}
	})
	return locationRes;
	
}
/**
 * @desc 多个对象合并
 * @return { Object } 返回合并后的
 *e.g:  var obj1 = {name: 'xz', age: '22', id: '225'}
 * 		var obj2 = {name: 'hong', id: '18', wx: '511535683'}
 *     console.log(this.extend(obj1,obj2))
 *     // 打印结果
 *     { "name": "hong", "age": "22", "id": "18", "wx": "511535683" }
 * 
 */
function extend() {
	var length = arguments.length
	var target = arguments[0] || {}
	if (typeof target !== 'object' && typeof target !== 'function') {
		target = {}
	}
	var i = 1
	if (length === 1) {
		target = this
		i--
	}
	for (i; i < length; i++) {
		var source = arguments[i]
		for (var key in source) {
			// 使用for in会遍历数组所有的可枚举属性，包括原型。
			if (Object.prototype.hasOwnProperty.call(source, key)) {
				target[key] = source[key]
			}
		}
	}
	return target
}
//toast提示信息
function showToast(options) {
	let configs = {
		icon: 'none',
		title: '提示',
		duration: 3000,
		...options,
	}
	uni.showToast({
		title: configs.title,
		icon: configs.icon
	});
}
/* 显示加载   */
function showLoading(options) {
	let configs = {
		mask: false,
		title: '请稍后...',
		...options,
	}
	uni.showLoading({
		title: configs.title,
		mask: configs.mask
	});

}
/* 隐藏加载   */
function hideLoading() {
	uni.hideLoading();

}
/*  处理网络图片和本地图片地址   */
function reImg(url) {
	//console.log()
	if (url.indexOf('data:image/png;base64,') !== -1 || url.indexOf('data:image/jpg;base64,') !== -1 || url.indexOf(
			'data:image/jpeg;base64') !== -1) {
		return url;
	}
	if (isEmpty(url)) {
		return "";
	} else if (!/(http|https):\/\/([\w.]+\/?)\S*/.test(url)) {
		return websiteConfigs.sourceUrl + url;
	} else {
		return url;
	}
}
//根据key获取storage
function getLocalStorage(key) {
	return uni.getStorageSync(key);
}

//根据key删除storage
function removeLocalStorage(key) {
	return uni.removeStorageSync(key);
}
/* 
 * 将cityNo 转 cityName
 * cityData:原数据
 * cityNo：二级地区编码
 */
function getCityName(cityData, cityNo) {
	if (!cityNo) return;
	if (!(cityData instanceof Array)) return;
	// 9112
	cityNo += "";
	for (let i = 0; i < cityData.length; i++) {
		let sheng = cityData[i];
		for (let j = 0; j < sheng.children.length; j++) {
			let shi = sheng.children[j];
			if (shi.value == cityNo) {
				// 使用return 终止循环
				return `${sheng.label}-${shi.label}`;
			}
		}
	}
}
/**
 * 验证是否为空
 * @param {*} 字符串 
 */
function isEmpty(obj) {
	if (typeof obj == 'String' || typeof obj == 'string') {
		obj = obj.replace(/(^\s*)|(\s*$)/g, "");
	}
	if (typeof obj == "undefined" || obj == null || obj == "") {
		return true;
	} else {
		return false;
	}
}


/* 
 * obj 转 params字符串参数  
 * 例子：{a:1,b:2} => a=1&b=2
 */
function objParseParam(obj) {
	let paramsStr = "";
	if (obj instanceof Array) return paramsStr;
	if (!(obj instanceof Object)) return paramsStr;
	for (let key in obj) {
		paramsStr += `${key}=${obj[key]}&`;
	}
	return paramsStr.substring(0, paramsStr.length - 1);
}
/* 
 * obj 转 路由地址带参数
 * 例子：{a:1,b:2} => /pages/index/index?a=1&b=2
 */
function objParseUrlAndParam(path, obj) {
	let url = path || "/";
	let paramsStr = "";
	if (obj instanceof Array) return url;
	if (!(obj instanceof Object)) return url;
	paramsStr = objParseParam(obj);
	paramsStr && (url += "?");
	url += paramsStr;
	return url;
}
/* 
 * 获取url字符串参数
 */
function getRequestParameters(locationhref) {
	let href = locationhref || "";
	let theRequest = new Object();
	let str = href.split("?")[1];
	if (str != undefined) {
		let strs = str.split("&");
		for (let i = 0; i < strs.length; i++) {
			theRequest[strs[i].split("=")[0]] = (strs[i].split("=")[1]);
		}
	}
	return theRequest;
}


//根据key value设置storage
function setLocalStorage(key, value) {
	uni.setStorageSync(key, value);
}
/* 获取当前页面信息 */
function getCurrentPage() {
	return getCurrentPages()[getCurrentPages().length - 1];
}
/**
 * @method checkisNeedUpdata
 * @desc  检查版本更新/升级
 * @return  null
 * @param { Function } checkSucccallbanc 检查成功后回调,回调里面传回是否需要更新和更新信息
 * 服务器需返回格式如下：
 * {
	"code": 200, 
	"message": "获取成功",
	"data": {
		"ios": { // ios更新信息
			"version": "1.4", // 后台填写的当前最新版本的app版本号，和客户端的globalConfigs.js里面配置的iosVersion如果相等则不跟新，如果不相等且atOnce为true时，会提示更新
			"download_url": "", // 需要下载的url，此url为应用市场的下载地址
			"log": "", // 更新日志内容，有后台填写并返回
			"atOnce": false, // 如果有更新，是否立即提示更新，为false时不更新，为true时会提示更新，次提示可用于app上架审核期间控制不提示更新
		},
		"android": { // 安卓更新信息
			"version": "1.5",// 后台填写的当前最新版本的app版本号，和客户端的globalConfigs.js里面配置的androidVersion如果相等则不跟新，如果不相等且atOnce为true时，会提示更新
			"download_url": "http://sapp.lhave.net/download/fuapp.apk", // 需要下载的url，此url为应用市场的下载地址
			"log": "最新修改内容", // 更新日志内容，有后台填写并返回
			"atOnce": true // 如果有更新，是否立即提示更新，为false时不更新，为true时会提示更新，次提示可用于app上架审核期间控制不提示更新
		}
	}
}

 */
function checkisNeedUpdata(checkSucccallbanc) {
	var _this = this;
	var hostVersion = ''; // 本地ios或安卓版本号
	var curVersionInfo = {}; // 当前版本信息 
	var _isNeedUpdata = false; // 是否需要更新
	console.log('调用更新了====', );
	fetch.request({
		url: '/index/system/updateInfo', // 更新地址，更新返回数据格式 http://sapp.lhave.net 此域名作测试用
		success: res => {
			if (200 == res.data.code) {
				console.log('请求res==', JSON.stringify(res));
				if (plus.os.name == 'Android') { // 安卓平台
					hostVersion = websiteConfigs.androidVersion; // 本地安卓版本号
					curVersionInfo = res.data.data.android;
					if (curVersionInfo.version !== hostVersion && curVersionInfo.hasOwnProperty('atOnce') && curVersionInfo.atOnce) {
						_isNeedUpdata = true;
					}
					checkSucccallbanc(_isNeedUpdata, res.data.data.android);

				} else if (plus.os.name == 'iOS') {
					curVersionInfo = res.data.ios;
					hostVersion = websiteConfigs.iosVersion; // 本地ios版本号
					if (curVersionInfo.version !== hostVersion && curVersionInfo.hasOwnProperty('atOnce') && curVersionInfo.atOnce) {
						_isNeedUpdata = true;
					}
					checkSucccallbanc(_isNeedUpdata, res.data.ios);
				}

			} else {

				checkSucccallbanc(false, res);
			}
		}
	});
}
/* @desc 拨打电话
 *@params {String} phoneNum 需要拨打的电话号码
 * 
 */
function callPhone(phoneNum) { // 拨打电话
	if (phoneNum) {
		uni.makePhoneCall({
			phoneNumber: phoneNum
		})
	} else {
		uni.showToast({
			title: '请填写电话号码',
			icon: 'none'
		})
	}

}
// 字符串拆分
function stringSplit(str, splitor) {
	if (str.split(splitor).length == 1) {
		str += ',';
	}
	return (str || '').split(splitor)[0]

}


//删除历史记录
function deleteHis(arr, datas) {
	for (let id in arr) {
		for (let i in datas.shopData) {
			for (let k in datas.shopData[i].data) {
				if (datas.shopData[i].data[k].id == arr[id]) {
					datas.shopData[i].data.splice(k, 1)
				}
			}
		}
	}
	return datas
}
//删除空时间
function deleteTime(datas) {
	for (let i in datas.shopData) {
		if (datas.shopData[i].data.length == 0) {
			datas.shopData.splice(i, 1)
		}
	}
	return datas
}
/**
 * 图片按宽高比例进行自动缩放
 * @param { Object } imgInfo
 *     图片信息
 * 
 * @param { Number } maxWidth允许的最大宽度
 * @param { Number } maxHeight允许的最大高度
 * @return { Object } image 返回修改后的image对象，包括计算后的宽高
 * @usage 
 *     调用：fitImg(imgUrl,100,100)
 */
function fitImg(imgInfo, maxWidth, maxHeight) {
	let image = imgInfo.detail;
	let imgWidth = image.width;
	let imgHeight = image.height;
	let scale = imgWidth / imgHeight; // 图片的宽高比
	if (imgWidth >= maxWidth) { // 当宽度超出限制最大宽度时以最大宽度为准计算高度
		image.w = maxWidth;
		image.h = maxWidth / scale;

	} else if (imgHeight >= maxHeight) {
		image.h = maxHeight;
		image.w = maxHeight * scale;
	}
	return image;

}

/* *
 * @desc 把json字符串转换成json，并获取指定字段
 * @param { String } jsonString 需要转换的json字符串
 * @retrun {Object} 返回转换后的json
 * @usage getJson('{a: 1,b: 2}') 则返回结果为： {a: 1,b: 2}
 * 
 */
function getJson(jsonString) {
	if (typeof jsonString == 'string') {
		try {
			var obj = JSON.parse(jsonString);
			if (typeof obj == 'object' && obj) {
				return JSON.parse(jsonString);
			} else {
				return jsonString;
			}

		} catch (e) {
			return jsonString;
		}
	} else {
		return jsonString;
	}
}
/* @method countDown
 * @des  计算剩倒计时还有多少天，时，分，秒，传入毫秒数进行倒计时，
 * @param {Number}  dayDiff 倒计时的毫秒数， 如：10000 
 * @param {Function} callback  通过此回调函数，把剩余的天，时，分，秒以对象的方式返回出去， {"day":"00","hour":"00","minute":"00","second":"05","timer": timer01}
 * 
 */
function countDown(dayDiff = 0, callback) {
	if (!dayDiff) return;
	let i = 0;
	let timer01 = setInterval(() => {
		i++;
		_show_time();
	}, 1000);
	let _tempDayDiff = dayDiff;

	function _show_time() {
		var int_day, int_hour, int_minute, int_second;
		if (dayDiff >= 0) {
			// 天时分秒换算
			int_day = Math.floor(dayDiff / 86400000)
			dayDiff -= int_day * 86400000;
			int_hour = Math.floor(dayDiff / 3600000)
			dayDiff -= int_hour * 3600000;
			int_minute = Math.floor(dayDiff / 60000)
			dayDiff -= int_minute * 60000;
			int_second = Math.floor(dayDiff / 1000)
			// 时分秒为单数时、前面加零站位
			int_day = int_day;
			int_hour = int_hour;
			int_minute = int_minute;
			int_second = _checkTime(int_second);
			callback({
				day: int_day,
				hour: int_hour,
				minute: int_minute,
				second: int_second,
				timer: timer01
			});
			dayDiff = _tempDayDiff - 1000 * i;
		} else {
			clearInterval(timer01);
		}
	}

	function _checkTime(it) { //将0-9的数字前面加上0，例1变为01
		if (it < 10) {
			it = "0" + it;
		}
		return it;
	}

}

/* @method throttle
 * @des  节流器，延时多少时间执行函数
 * @param {Function}  func 需要执行的函数
 * @param {Number} wait  等待时间
 * 
 */
function throttle(func, wait) {
	let timeout
	return function() {
		let that = this
		let args = arguments

		if (!timeout) {
			timeout = setTimeout(function() {
				timeout = null
				func.apply(that, args)
			}, wait)
		}
	}
}
/* @method replaceImgPath
 * @des  把图片路径中的\替换为/
 * @param {String}  url 需要替换的url
 * 
 */
function replaceImgPath(url) {
	if (!url) return;
	return url.replace(/\\/g, '/');
}
/* @method swapArray
 * @des 数组前后移动
 * @param {Array}  arr 需要移动的数组
 *  @param {Integger}  index1 需要移动元素的位置索引
 * @param {Integger}  index2 需要移动到的索引，如果往前移动，则index2 = index1-1;如果往后移动，则index2 = index2+1
 * @example swapArray(arr, index, index-1); 向前移动，swapArray(arr, index, index+1);向后移动
 * @return {Array} 返回排序后的数组
 */
function swapArray(arr, index1, index2) {
	arr[index1] = arr.splice(index2, 1, arr[index1])[0];
	return arr;
}

function trim(str) { //删除左右两端的空格
	return str.replace(/(^\s*)|(\s*$)/g, "");
}

function showMsg(str) { //显示打印信息
	return false;
}
/* @method isHasparam
 * @des 模板渲染中判断某个对象是否有某个属性
 * @param {Object}  obj 需要判断的对象
 *  @param {String}  param 需要判断的属性
 * @return {Boolean} 返回排ture或false
 */
function isHasparam(obj, param) { // 是否有某个属性
	if (obj && param) {
		return obj.hasOwnProperty(param)
	}
	return false;

}
function phoneCall(phoneNum){
	
	if(!phoneNum){
		uni.showToast({
			title: '拨打的电话不能为空',
			icon: 'none'
			
		})
		return;
	}
	console.log('phoneNum===',phoneNum);
	if(phoneNum.length !== 11){
		uni.showToast({
			title: '手机号码不正确',
			icon: 'none'
			
		})
		return;
	}
	uni.makePhoneCall({
	    phoneNumber: phoneNum
	});
	
	
}
//获取前面几天的时间
function Daytime(num){
	let nowDate = new Date();
	let dayTime = 24*60*60*1000;
	nowDate.setTime(nowDate.getTime()-num*24*60*60*1000);
	let months = nowDate.getMonth()+1>=10?nowDate.getMonth()+1:'0'+Number(nowDate.getMonth()+1);
	let days = nowDate.getDate()>=10?nowDate.getDate():'0'+nowDate.getDate();
	let s1 = nowDate.getFullYear()+"-" + months + "-" + days;
	return s1;
}
//获取当前时间之前周的开始时间
function weekTime(num){
    let nowDate = new Date().getDay();
    if(nowDate==0){
     //星期天
       return Daytime(6+num*7)
    }else{
       return Daytime(num*7+nowDate-1)
    }
}
//获取之前周的结束时间
function weekTimeEnd(num){
    let nowDate = new Date().getDay();
    if(nowDate==0){
     //星期天
       return Daytime(7+7*num)
    }else{
       return Daytime(nowDate+num*7)
    }
}
//获取当前时间前几月的时间
function monthTime(type){
	let nowdays = new Date(); 
	let year = nowdays.getFullYear();
	let month = nowdays.getMonth();
	if(month==0){
		month = 12;
		year = year-1;
	}
	if(month<10){
		month = '0'+month;
	}
	var myDate = new Date(year,month,0);
	var startDate = year+'-'+month+'-01'; //上个月第一天
	var endDate = year+'-'+month+'-'+myDate.getDate();//上个月最后一天
	if(type==-1){
		return endDate
	}else{
		return startDate
	}
}
/* 日期补全 */
function MonthAll(type){
	if(type==1){
		let Day = (new Date()).getDate();
		if(Day.toString().length == 1){
			return "0"+Day.toString();
		}else{
			return Day.toString();
		}
	}else{
		let Month = ((new Date()).getMonth())+1;
		if(Month.toString().length == 1){
			return "0"+Month.toString();
		}else{
			return Month.toString();
		}
	}
	
}

/**
 *  @description  保留两位小数，但去除无效位 如： 3.00则为3,2.10位2.1,2.129位2.13
 * @param {Number} num  需要传入转换的数字
 * @param {Number} pointNum  需要保留小数点的位数，默认为2
 * @return {Number} result 返回转换后的数字
  */
function keepTwoDecimal(num,pointNum=2) {
 var result = parseFloat(num);
 let _point = Math.pow(10,pointNum);
 if (isNaN(result)) {
 return false;
 }
 result = Math.round(num * _point) / _point;
 return result;
}
/**
   * 
   * @description  获取微信订阅消息的权限
   * @return  null  无返回值
   * 
   * */
function getSubscriptions(){
	wx.getSetting({
		withSubscriptions: true,
		success: res => {
			for (let i = 0; i < websiteConfigs.servMsgTemplete.length; i++) {
				if (
					res.subscriptionsSetting && !res.subscriptionsSetting.hasOwnProperty('itemSettings') ||
					(res.subscriptionsSetting && res.subscriptionsSetting.hasOwnProperty('itemSettings') && !res.subscriptionsSetting.itemSettings[websiteConfigs.servMsgTemplete[i]])
				) {
					wx.requestSubscribeMessage({
						tmplIds: websiteConfigs.servMsgTemplete
					});
				}
			}
		}
	});
}
function deleteKeys(obj,delKeys=''){
	if(!delKeys) return obj;
	if(!obj) return;
	let nameArr = delKeys.split('.');
	let len = nameArr.length;
	 let temp_obj = obj[nameArr[0]] ;
	if (len >= 2) {
		for (let i = 1; i < len - 1; i++) {
			temp_obj = temp_obj[nameArr[i]];
		}
		delete temp_obj[nameArr[len - 1]];
	} else {
		// 单层级变量，在state就是一个普通变量的情况
		delete obj[delKeys];
	}
	return obj;
	
}
function setKeyValues(obj,keys = '',val){
	if(!delKeys) return obj;
	if(!obj) return;
	let nameArr = keys.split('.');
	let len = nameArr.length;
	let temp_obj = obj[nameArr[0]] ;
	if (len >= 2) {
		for (let i = 1; i < len - 1; i++) {
			temp_obj = temp_obj[nameArr[i]];
		}
		temp_obj[nameArr[len - 1]] = val;
	} else {
		// 单层级变量，在state就是一个普通变量的情况
		obj[keys] = val;
	}
	return obj;
	
}
module.exports = {
	formatDate, // 时间格式化
	showToast, // 显示提示
	showLoading, // 显示等待框
	hideLoading, // 隐藏加载提示
	getLocalStorage, // 获取本地存储LocalStorage
	removeLocalStorage, // 删除本地存储LocalStorage
	setLocalStorage, // 设置本地存储LocalStorage
	getCityName, // 将cityNo 转 cityName
	objParseParam, // obj 转 params字符串参数  
	objParseUrlAndParam, // obj 转 路由地址带参数
	getRequestParameters, //  获取url字符串参数
	getCurrentPage, // 获取当前页面信息
	isEmpty, // 判断是否为空
	reImg, // 处理图片
	checkisNeedUpdata, // app更新
	callPhone, // 拨打电话
	stringSplit, // 字符串拆分为数组
	deleteHis,
	deleteTime,
	fitImg, // 图片按宽高比例进行自动缩放
	getJson, // json字符串转成json类型
	countDown, // 倒计时：天时分秒
	throttle, // 节流器
	replaceImgPath, // 图片路径中的\替换为/
	swapArray, // 数组上下移动排序
	trim, // 删除字符串左右空格
	showMsg, //显示打印信息
	isHasparam, // 判断某个对象是否有某个属性
	phoneCall, // 
	getLocalPosition, // 根据纬度经度获取具体地理位置（百度地图）
	Daytime, //获取前面几天的时间
	weekTime, //获取前面几周的开始时间
	weekTimeEnd,//获取线面几周的结束时间 
	monthTime,//获取上月时间
	MonthAll,//获取完整月份
	keepTwoDecimal, // 保留两位小数，但去除无效位 如： 3.00则为3,2.10位2.1,2.129位2.13
	getSubscriptions, // 获取微信订阅消息权限，在配置文件中进行配置
	deleteKeys, // 根据key删除对象某个键值，数组不包括在内
	setKeyValues, // 根据键设置某个对象的值，数组不包括在内
}
